Advances in memory management and processor performance have permitted more and more complicated software applications to be utilized in the industry. Also, these advances have permitted multiple applications to run simultaneously on the same hardware architecture.
Initially, the technology advancements were realized via hardware and software improvements that created a single logical machine from multiple cooperating processors (multiprocessor architectures). However, it was soon realized that additional design improvements were needed to fully utilize the potential of multiprocessor architectures.
One design improvement was the implementation of Non-Uniform Memory Access techniques or a Non-Uniform Memory Architecture (NUMA). With NUMA, memory access time depends on a particular memory's location relative to a requesting processor (in a multicore architecture). So, a processor can access its own local memory much faster than non-local memory (such as: non-volatile storage, memory local to a different processor, memory shared between processors, etc.).
One problem associated with NUMA approaches is that data is discarded from local memory of a particular processor when that processor needs to retain some other data in its local memory and there is not enough room to retain both. However, the discarded data may still be needed by the local processor that had to discard it.
Another problem with NUMA approaches is that dirty data (data that has to be written to disk (non volatile storage)) requires the processor to expend Input/Output (I/O) disk reads and writes to move the dirty data from local memory to disk and this can substantially impact processor performance for other waiting operations.
Essentially, with NUMA approaches each local memory is independently managed and operated by its particular processor. There is no cooperation between the processors and their local memories. Therefore, some local memories tend to be underutilized whereas other local memories are over utilized. This creates imbalances within the multicore architecture that can degrade memory and processor performances over time.